{ "cells": [ { "cell_type": "code", "execution_count": 21, "id": "76cd10db", "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "\n", "from sklearn.preprocessing import LabelEncoder\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.naive_bayes import GaussianNB\n", "from sklearn.linear_model import LogisticRegression\n", "from sklearn.neighbors import KNeighborsClassifier\n", "from sklearn.metrics import accuracy_score, roc_auc_score" ] }, { "cell_type": "code", "execution_count": 22, "id": "e9c4b3af", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
Loan_IDGenderMarriedDependentsEducationSelf_EmployedApplicantIncomeCoapplicantIncomeLoanAmountLoan_Amount_TermCredit_HistoryProperty_AreaLoan_Status
0LP001002MaleNo0GraduateNo58490.0NaN360.01.0UrbanY
1LP001003MaleYes1GraduateNo45831508.0128.0360.01.0RuralN
2LP001005MaleYes0GraduateYes30000.066.0360.01.0UrbanY
3LP001006MaleYes0Not GraduateNo25832358.0120.0360.01.0UrbanY
4LP001008MaleNo0GraduateNo60000.0141.0360.01.0UrbanY
\n", "
" ], "text/plain": [ " Loan_ID Gender Married Dependents Education Self_Employed \\\n", "0 LP001002 Male No 0 Graduate No \n", "1 LP001003 Male Yes 1 Graduate No \n", "2 LP001005 Male Yes 0 Graduate Yes \n", "3 LP001006 Male Yes 0 Not Graduate No \n", "4 LP001008 Male No 0 Graduate No \n", "\n", " ApplicantIncome CoapplicantIncome LoanAmount Loan_Amount_Term \\\n", "0 5849 0.0 NaN 360.0 \n", "1 4583 1508.0 128.0 360.0 \n", "2 3000 0.0 66.0 360.0 \n", "3 2583 2358.0 120.0 360.0 \n", "4 6000 0.0 141.0 360.0 \n", "\n", " Credit_History Property_Area Loan_Status \n", "0 1.0 Urban Y \n", "1 1.0 Rural N \n", "2 1.0 Urban Y \n", "3 1.0 Urban Y \n", "4 1.0 Urban Y " ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#import data\n", "df = pd.read_csv('loan_data.csv')\n", "df.head()" ] }, { "cell_type": "markdown", "id": "d3122ccf", "metadata": {}, "source": [ "### Missing Values" ] }, { "cell_type": "code", "execution_count": 23, "id": "cae1ab70", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Missing values in each column:\n", " Loan_ID 0\n", "Gender 13\n", "Married 3\n", "Dependents 15\n", "Education 0\n", "Self_Employed 32\n", "ApplicantIncome 0\n", "CoapplicantIncome 0\n", "LoanAmount 22\n", "Loan_Amount_Term 14\n", "Credit_History 50\n", "Property_Area 0\n", "Loan_Status 0\n", "dtype: int64\n" ] } ], "source": [ "#check for missing values\n", "missing_values = df.isnull().sum()\n", "print(\"Missing values in each column:\\n\", missing_values)" ] }, { "cell_type": "code", "execution_count": 24, "id": "1d307a2f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Missing values after imputation:\n", " Loan_ID 0\n", "Gender 0\n", "Married 0\n", "Dependents 0\n", "Education 0\n", "Self_Employed 0\n", "ApplicantIncome 0\n", "CoapplicantIncome 0\n", "LoanAmount 0\n", "Loan_Amount_Term 0\n", "Credit_History 0\n", "Property_Area 0\n", "Loan_Status 0\n", "dtype: int64\n" ] } ], "source": [ "#impute for missing values\n", "categorical_columns = ['Gender', 'Married', 'Dependents', 'Self_Employed', 'Loan_Amount_Term']\n", "for column in categorical_columns:\n", " df[column].fillna(df[column].mode()[0], inplace=True)\n", "\n", "df['Credit_History'].fillna(df['Credit_History'].mode()[0], inplace=True)\n", "\n", "df['LoanAmount'].fillna(df['LoanAmount'].median(), inplace=True)\n", "\n", "#double check missing values\n", "missing_values_post_imputation = df.isnull().sum()\n", "print(\"Missing values after imputation:\\n\", missing_values_post_imputation)" ] }, { "cell_type": "markdown", "id": "f89dd152", "metadata": {}, "source": [ "#### Justification for Imputing Missing Values" ] }, { "cell_type": "markdown", "id": "adb887c4", "metadata": {}, "source": [ "Since this assignment requires making loan predictions, I believe that imputing missing values is preferable to dropping missing value rows entirely. The number of missing values in each column is relatively low compared to the overall dataset, so keeping rows by imputing helps preserve data, which helps improve predictions. I chose to impute categorical columns (Gender, Married, Dependents, etc) with their most common values (mode), as this maintains typical distribution patterns for these features. For numerical data like Loan Amount, I used median imputation, as the median is less sensitive to outliers." ] }, { "cell_type": "markdown", "id": "59993cd9", "metadata": {}, "source": [ "### Checking for Outliers" ] }, { "cell_type": "code", "execution_count": 6, "id": "cc4f4ceb", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#identifying outliers using IQR\n", "def identify_outliers(column):\n", " Q1 = df[column].quantile(0.25)\n", " Q3 = df[column].quantile(0.75)\n", " IQR = Q3 - Q1\n", " lower_bound = Q1 - 1.5 * IQR\n", " upper_bound = Q3 + 1.5 * IQR\n", " outliers = df[(df[column] < lower_bound) | (df[column] > upper_bound)]\n", " return outliers\n", "\n", "#create graphs for visualization\n", "plt.figure(figsize=(12, 6))\n", "for i, column in enumerate(['ApplicantIncome', 'CoapplicantIncome', 'LoanAmount']):\n", " plt.subplot(1, 3, i + 1)\n", " sns.boxplot(data=df, y=column)\n", " plt.title(f'Box Plot of {column}')\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "07140005", "metadata": {}, "source": [ "As we can see from the above box plots, there are a number of outliers in the numerical columns." ] }, { "cell_type": "code", "execution_count": 7, "id": "0f7a4574", "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Outliers in ApplicantIncome:\n", "Index: 9, ApplicantIncome: 12841\n", "Index: 34, ApplicantIncome: 12500\n", "Index: 54, ApplicantIncome: 11500\n", "Index: 67, ApplicantIncome: 10750\n", "Index: 102, ApplicantIncome: 13650\n", "Index: 106, ApplicantIncome: 11417\n", "Index: 115, ApplicantIncome: 14583\n", "Index: 119, ApplicantIncome: 10408\n", "Index: 126, ApplicantIncome: 23803\n", "Index: 128, ApplicantIncome: 10513\n", "Index: 130, ApplicantIncome: 20166\n", "Index: 138, ApplicantIncome: 14999\n", "Index: 144, ApplicantIncome: 11757\n", "Index: 146, ApplicantIncome: 14866\n", "Index: 155, ApplicantIncome: 39999\n", "Index: 171, ApplicantIncome: 51763\n", "Index: 183, ApplicantIncome: 33846\n", "Index: 185, ApplicantIncome: 39147\n", "Index: 191, ApplicantIncome: 12000\n", "Index: 199, ApplicantIncome: 11000\n", "Index: 254, ApplicantIncome: 16250\n", "Index: 258, ApplicantIncome: 14683\n", "Index: 271, ApplicantIncome: 11146\n", "Index: 278, ApplicantIncome: 14583\n", "Index: 284, ApplicantIncome: 20667\n", "Index: 308, ApplicantIncome: 20233\n", "Index: 324, ApplicantIncome: 15000\n", "Index: 333, ApplicantIncome: 63337\n", "Index: 369, ApplicantIncome: 19730\n", "Index: 370, ApplicantIncome: 15759\n", "Index: 409, ApplicantIncome: 81000\n", "Index: 424, ApplicantIncome: 14880\n", "Index: 432, ApplicantIncome: 12876\n", "Index: 438, ApplicantIncome: 10416\n", "Index: 443, ApplicantIncome: 37719\n", "Index: 467, ApplicantIncome: 16692\n", "Index: 475, ApplicantIncome: 16525\n", "Index: 478, ApplicantIncome: 16667\n", "Index: 483, ApplicantIncome: 10833\n", "Index: 487, ApplicantIncome: 18333\n", "Index: 493, ApplicantIncome: 17263\n", "Index: 506, ApplicantIncome: 20833\n", "Index: 509, ApplicantIncome: 13262\n", "Index: 525, ApplicantIncome: 17500\n", "Index: 533, ApplicantIncome: 11250\n", "Index: 534, ApplicantIncome: 18165\n", "Index: 561, ApplicantIncome: 19484\n", "Index: 572, ApplicantIncome: 16666\n", "Index: 594, ApplicantIncome: 16120\n", "Index: 604, ApplicantIncome: 12000\n", "\n", "\n", "Outliers in CoapplicantIncome:\n", "Index: 9, CoapplicantIncome: 10968.0\n", "Index: 12, CoapplicantIncome: 8106.0\n", "Index: 38, CoapplicantIncome: 7210.0\n", "Index: 122, CoapplicantIncome: 8980.0\n", "Index: 135, CoapplicantIncome: 7750.0\n", "Index: 177, CoapplicantIncome: 11300.0\n", "Index: 180, CoapplicantIncome: 7250.0\n", "Index: 253, CoapplicantIncome: 7101.0\n", "Index: 349, CoapplicantIncome: 6250.0\n", "Index: 372, CoapplicantIncome: 7873.0\n", "Index: 402, CoapplicantIncome: 20000.0\n", "Index: 417, CoapplicantIncome: 20000.0\n", "Index: 444, CoapplicantIncome: 8333.0\n", "Index: 506, CoapplicantIncome: 6667.0\n", "Index: 513, CoapplicantIncome: 6666.0\n", "Index: 523, CoapplicantIncome: 7166.0\n", "Index: 581, CoapplicantIncome: 33837.0\n", "Index: 600, CoapplicantIncome: 41667.0\n", "\n", "\n", "Outliers in LoanAmount:\n", "Index: 5, LoanAmount: 267.0\n", "Index: 9, LoanAmount: 349.0\n", "Index: 21, LoanAmount: 315.0\n", "Index: 34, LoanAmount: 320.0\n", "Index: 54, LoanAmount: 286.0\n", "Index: 67, LoanAmount: 312.0\n", "Index: 83, LoanAmount: 265.0\n", "Index: 126, LoanAmount: 370.0\n", "Index: 130, LoanAmount: 650.0\n", "Index: 135, LoanAmount: 290.0\n", "Index: 155, LoanAmount: 600.0\n", "Index: 161, LoanAmount: 275.0\n", "Index: 171, LoanAmount: 700.0\n", "Index: 177, LoanAmount: 495.0\n", "Index: 233, LoanAmount: 280.0\n", "Index: 253, LoanAmount: 279.0\n", "Index: 258, LoanAmount: 304.0\n", "Index: 260, LoanAmount: 330.0\n", "Index: 278, LoanAmount: 436.0\n", "Index: 308, LoanAmount: 480.0\n", "Index: 324, LoanAmount: 300.0\n", "Index: 325, LoanAmount: 376.0\n", "Index: 333, LoanAmount: 490.0\n", "Index: 351, LoanAmount: 308.0\n", "Index: 369, LoanAmount: 570.0\n", "Index: 372, LoanAmount: 380.0\n", "Index: 381, LoanAmount: 296.0\n", "Index: 391, LoanAmount: 275.0\n", "Index: 409, LoanAmount: 360.0\n", "Index: 432, LoanAmount: 405.0\n", "Index: 487, LoanAmount: 500.0\n", "Index: 506, LoanAmount: 480.0\n", "Index: 514, LoanAmount: 311.0\n", "Index: 523, LoanAmount: 480.0\n", "Index: 525, LoanAmount: 400.0\n", "Index: 536, LoanAmount: 324.0\n", "Index: 561, LoanAmount: 600.0\n", "Index: 572, LoanAmount: 275.0\n", "Index: 592, LoanAmount: 292.0\n", "Index: 600, LoanAmount: 350.0\n", "Index: 604, LoanAmount: 496.0\n", "\n", "\n" ] } ], "source": [ "#shows the outliers in each column and the index of the row.\n", "def print_outliers(column):\n", " outliers = identify_outliers(column)\n", " print(f\"Outliers in {column}:\")\n", " for idx, value in outliers[column].items():\n", " print(f\"Index: {idx}, {column}: {value}\")\n", " print(\"\\n\")\n", "\n", "print_outliers('ApplicantIncome')\n", "print_outliers('CoapplicantIncome')\n", "print_outliers('LoanAmount')" ] }, { "cell_type": "markdown", "id": "4360fa74", "metadata": {}, "source": [ "As we can see in the above printout and graphs, there are quite a large number of outliers. However, I believe the correct option is to keep the outliers in the dataset. The three columns that were checked are ApplicantIncome, CoapplicantIncome, and LoanAmount. In the real world, there's a large amount of variance in all of these three columns. Different applicants with different incomes have different loans to apply to, so it makes sense that the values would range. Thus, I believe it makes sense to keep the outliers, in order to have a good view of the differences in loan application and acceptance that happens in the real world." ] }, { "cell_type": "markdown", "id": "0127a19e", "metadata": {}, "source": [ "### Discretizing ApplicantIncome, CoapplicantIncome, LoanAmount, and Loan_Amount_Term" ] }, { "cell_type": "code", "execution_count": 8, "id": "ba4175cd", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " ApplicantIncome CoapplicantIncome LoanAmount Loan_Amount_Term\n", "0 Low Income No Co-Applicant Small Loan Long Term\n", "1 Low Income Low Income Small Loan Long Term\n", "2 Low Income No Co-Applicant Small Loan Long Term\n", "3 Low Income Low Income Small Loan Long Term\n", "4 Low Income No Co-Applicant Small Loan Long Term\n" ] } ], "source": [ "#discretizing columns\n", "df['ApplicantIncome'] = pd.cut(df['ApplicantIncome'], \n", " bins=[0, 30000, 80000, float('inf')], \n", " labels=['Low Income', 'Medium Income', 'High Income'])\n", "\n", "df['CoapplicantIncome'] = pd.cut(df['CoapplicantIncome'], \n", " bins=[-1, 0, 15000, 40000, float('inf')], \n", " labels=['No Co-Applicant', 'Low Income', 'Medium Income', 'High Income'])\n", "\n", "df['LoanAmount'] = pd.cut(df['LoanAmount'], \n", " bins=[0, 150, 300, float('inf')], \n", " labels=['Small Loan', 'Medium Loan', 'Large Loan'])\n", "\n", "df['Loan_Amount_Term'] = pd.cut(df['Loan_Amount_Term'], \n", " bins=[0, 120,240, float('inf')], \n", " labels=['Short Term', 'Medium Term', 'Long Term'])\n", "\n", "#check changes\n", "print(df[['ApplicantIncome', 'CoapplicantIncome', 'LoanAmount', 'Loan_Amount_Term']].head())" ] }, { "cell_type": "markdown", "id": "f00573e8", "metadata": {}, "source": [ "In each of the above columns, I divided the values into a few different categories. For ApplicantIncome, I chose to divide it into Low Income (0 - 30,000), Medium Income (30,001 to 80,000), and High Income (80,001 and above.) This was done to generally imitate income values in the real world, while specifically looking at the average values in this data set.\n", "\n", "For CoapplicantIncome, I chose to do effectively the same thing - however, I also added a label for the columns with 0 income, which I believe means that there isn't a coapplicant present. \n", "\n", "For LoanAmount, the divisions between small, medium and large loan were effectively planned around the average of loan amount values. The average for the column was 146.41, which places my values at good markers for what small, medium, and large loans might look like.\n", "\n", "Lastly, for Loan_Amount_Term, it wasn't exactly as with the other columns. The terms were of a few set amounts - 84, 120, 180, 240, 360, and 480. Due to this, I broke the loans up into categories, Short (0-120), Medium (121-240) and Long (above 240)." ] }, { "cell_type": "code", "execution_count": 9, "id": "33ca2d8a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Selected Features for Predictors:\n", "['ApplicantIncome', 'CoapplicantIncome', 'LoanAmount', 'Loan_Amount_Term']\n", " ApplicantIncome CoapplicantIncome LoanAmount Loan_Amount_Term\n", "0 Low Income No Co-Applicant Small Loan Long Term\n", "1 Low Income Low Income Small Loan Long Term\n", "2 Low Income No Co-Applicant Small Loan Long Term\n", "3 Low Income Low Income Small Loan Long Term\n", "4 Low Income No Co-Applicant Small Loan Long Term\n" ] } ], "source": [ "all_columns = df.columns\n", "\n", "#excluding 'Loan_Status' from predictors\n", "predictors = ['ApplicantIncome', 'CoapplicantIncome', 'LoanAmount', 'Loan_Amount_Term']\n", "\n", "print(\"Selected Features for Predictors:\")\n", "print(predictors)\n", "\n", "df_selected = df[predictors]\n", "\n", "print(df_selected.head())" ] }, { "cell_type": "markdown", "id": "c4286a38", "metadata": {}, "source": [ "For predicting loan approval, I focused on features that are directly related to financial situations, such as ApplicantIncome, CoapplicantIncome, LoanAmount, and Loan_Amount_Term. I believe that these four show direct involvement in loan prediction, wheras the other features like Gender, MaritalStatus, Dependents, and Education are personal qualities. While these features do impact loan approval in the real world, for my models, I wanted to focus on specifically financial status." ] }, { "cell_type": "code", "execution_count": 10, "id": "60c8d815", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " ApplicantIncome CoapplicantIncome LoanAmount Loan_Amount_Term \\\n", "0 1 3 2 0 \n", "1 1 1 2 0 \n", "2 1 3 2 0 \n", "3 1 1 2 0 \n", "4 1 3 2 0 \n", "\n", " Loan_Status \n", "0 1 \n", "1 0 \n", "2 1 \n", "3 1 \n", "4 1 \n" ] } ], "source": [ "label_encoder = LabelEncoder()\n", "\n", "categorical_columns = ['ApplicantIncome', 'CoapplicantIncome', 'LoanAmount', 'Loan_Amount_Term', 'Loan_Status']\n", "\n", "for col in categorical_columns:\n", " df[col] = label_encoder.fit_transform(df[col])\n", "\n", "print(df[categorical_columns].head())" ] }, { "cell_type": "markdown", "id": "fea9779d", "metadata": {}, "source": [ "### Training Models" ] }, { "cell_type": "code", "execution_count": 14, "id": "3afb8f90", "metadata": {}, "outputs": [], "source": [ "#focusing on just ApplicantIncome, CoapplicantIncome, LoanAmount, Loan_Amount_term.\n", "X = df[['ApplicantIncome', 'CoapplicantIncome', 'LoanAmount', 'Loan_Amount_Term']]\n", "y = df['Loan_Status']\n", "\n", "#splitting data\n", "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)" ] }, { "cell_type": "code", "execution_count": 15, "id": "2f50ef72", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Naive Bayes:\n", " Accuracy: 0.6341\n", " AUC Score: 0.5445\n" ] } ], "source": [ "#training model\n", "nb_model = GaussianNB()\n", "nb_model.fit(X_train, y_train)\n", "\n", "#predicitng and evaluating\n", "y_pred_nb = nb_model.predict(X_test)\n", "accuracy_nb = accuracy_score(y_test, y_pred_nb)\n", "auc_nb = roc_auc_score(y_test, nb_model.predict_proba(X_test)[:, 1])\n", "\n", "print(\"Naive Bayes:\")\n", "print(f\" Accuracy: {accuracy_nb:.4f}\")\n", "print(f\" AUC Score: {auc_nb:.4f}\")" ] }, { "cell_type": "code", "execution_count": 16, "id": "c2e142b5", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Logistic Regression:\n", " Accuracy: 0.6504\n", " AUC Score: 0.5576\n" ] } ], "source": [ "#training model\n", "lr_model = LogisticRegression()\n", "lr_model.fit(X_train, y_train)\n", "\n", "#predicitng and evaluating\n", "y_pred_lr = lr_model.predict(X_test)\n", "accuracy_lr = accuracy_score(y_test, y_pred_lr)\n", "auc_lr = roc_auc_score(y_test, lr_model.predict_proba(X_test)[:, 1])\n", "\n", "print(\"Logistic Regression:\")\n", "print(f\" Accuracy: {accuracy_lr:.4f}\")\n", "print(f\" AUC Score: {auc_lr:.4f}\")" ] }, { "cell_type": "code", "execution_count": 17, "id": "4b067d44", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "K-Nearest Neighbors:\n", " Accuracy: 0.5854\n", " AUC Score: 0.5888\n" ] } ], "source": [ "#training model\n", "knn_model = KNeighborsClassifier(n_neighbors=5)\n", "knn_model.fit(X_train, y_train)\n", "\n", "#predicitng and evaluating\n", "y_pred_knn = knn_model.predict(X_test)\n", "accuracy_knn = accuracy_score(y_test, y_pred_knn)\n", "auc_knn = roc_auc_score(y_test, knn_model.predict_proba(X_test)[:, 1])\n", "\n", "print(\"K-Nearest Neighbors:\")\n", "print(f\" Accuracy: {accuracy_knn:.4f}\")\n", "print(f\" AUC Score: {auc_knn:.4f}\")" ] }, { "cell_type": "markdown", "id": "7beca591", "metadata": {}, "source": [ "I chose to use Naive Bayes, Logistic Regression, and K-Nearest Neighbors, as a way to show off a variety of different modeling approaches. Naive Bayes is a probabilistic model, Logistic Regression is a linear model, and K-Nearest Neighbor is a non-linear model. Although each of the models do have various weaknesses, most of the weaknesses observed in these models don't apply to this dataset and are overshadowed by their positives. For instance, Logistic Regression is unable to handle a large number of categorical features, but that doesn't really apply to this dataset (we're only looking at 4 of the features). Additionally, each of the models are easy to train and understand." ] }, { "cell_type": "markdown", "id": "1faae0eb", "metadata": {}, "source": [ "### Analysis" ] }, { "cell_type": "markdown", "id": "a6fb0506", "metadata": {}, "source": [ "Among the three models, Logistic Regression achieved the highest accuracy (0.6504) and a reasonably competitive AUC score (0.5576). Although K-Nearest Neighbors (KNN) had a slightly higher AUC (0.5888), its overall accuracy was lower (0.5854), meaning it may not be as reliable for predictions on this dataset. Naive Bayes, with an accuracy of 0.6341 and the lowest AUC (0.5445), also underperformed compared to Logistic Regression." ] }, { "cell_type": "markdown", "id": "d7f7f363", "metadata": {}, "source": [ "Logistic Regression seemed to be the most effective model for predicting loan approval status, as it returned the highest accuracy while maintaining a decent AUC score. The strength of this model lies in its simplicity and its ability to generalize across the data without overfitting. Logistic Regression performed better than Naive Bayes, which struggled with the independence assumption of features, and K-Nearest Neighbors, which was sensitive to data distribution and potential outliers, leading to lower accuracy.\n", "\n", "While KNN had a marginally higher AUC score, its overall accuracy was lower. In contrast, Logistic Regression provides a good balance, making it suitable for this dataset. Due to its balance and average accuracy scoring, I think that Logistic Regression is good for this task." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.4" } }, "nbformat": 4, "nbformat_minor": 5 }